home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Environments / PowerMacOberon feb96 / Source / CRP.Mod (.txt) < prev    next >
Encoding:
Oberon Text  |  1995-07-19  |  18.1 KB  |  655 lines  |  [TEXT/.Ob4]
  1. Syntax10.Scn.Fnt
  2. (* parser module generated by Coco-R *)
  3. MODULE CRP; 
  4. IMPORT CRS, CRT, CRA, CRX, Sets, Texts, Oberon;
  5. CONST 
  6.     maxP        = 39;
  7.   maxT        = 38;
  8.   nrSets = 18;
  9.     setSize = 32;  nSets = (maxT DIV setSize) + 1;
  10.     SymbolSet = ARRAY nSets OF SET;
  11.     sym:     INTEGER;   (* current input symbol *)
  12.     symSet:  ARRAY nrSets OF SymbolSet;
  13. CONST
  14.   ident = 0; string = 1; (*symbol kind*)
  15.   str: ARRAY 32 OF CHAR;
  16.   w:   Texts.Writer;
  17.   genScanner: BOOLEAN;
  18. PROCEDURE SemErr(nr: INTEGER);
  19. BEGIN
  20.   CRS.Error(200+nr, CRS.pos);
  21. END SemErr;
  22. PROCEDURE MatchLiteral(sp: INTEGER); (*store string either as token or as literal*)
  23.   VAR sn, sn1: CRT.SymbolNode; matchedSp: INTEGER;
  24. BEGIN
  25.   CRT.GetSym(sp, sn);
  26.   CRA.MatchDFA(sn.name, sp, matchedSp);
  27.   IF matchedSp # CRT.noSym THEN
  28.     CRT.GetSym(matchedSp, sn1); sn1.struct := CRT.classLitToken; CRT.PutSym(matchedSp, sn1);
  29.     sn.struct := CRT.litToken
  30.   ELSE sn.struct := CRT.classToken;
  31.   END;
  32.   CRT.PutSym(sp, sn)
  33. END MatchLiteral;
  34. PROCEDURE SetCtx(gp: INTEGER); (*set transition code to CRT.contextTrans*)
  35.   VAR gn: CRT.GraphNode;
  36. BEGIN
  37.   WHILE gp > 0 DO
  38.     CRT.GetNode(gp, gn);
  39.     IF gn.typ IN {CRT.char, CRT.class} THEN
  40.         gn.p2 := CRT.contextTrans; CRT.PutNode(gp, gn)
  41.     ELSIF gn.typ IN {CRT.opt, CRT.iter} THEN SetCtx(gn.p1)
  42.     ELSIF gn.typ = CRT.alt THEN SetCtx(gn.p1); SetCtx(gn.p2)
  43.     END;
  44.     gp := gn.next
  45.   END
  46. END SetCtx;
  47. PROCEDURE SetDDT(s: ARRAY OF CHAR);
  48.   VAR name: ARRAY 64 OF CHAR; i: INTEGER; ch: CHAR;
  49. BEGIN
  50.   i := 1;
  51.   WHILE s[i] # 0X DO
  52.     ch := s[i]; INC(i);
  53.     IF (ch >= "0") & (ch <= "9") THEN CRT.ddt[ORD(ch)-ORD("0")] := TRUE END
  54.   END
  55. END SetDDT;
  56. PROCEDURE FixString (VAR s: ARRAY OF CHAR; len: INTEGER);
  57.     VAR double: BOOLEAN; i: INTEGER;
  58. BEGIN
  59.     double := FALSE;
  60.     FOR i := 0 TO len-2 DO
  61.         IF s[i] = '"' THEN double := TRUE ELSIF s[i] = " " THEN SemErr(24) END
  62.     END;
  63.     IF ~ double THEN s[0] := '"'; s[len-1] := '"' END
  64. END FixString;
  65. (*-------------------------------------------------------------------------*)
  66. PROCEDURE Error (n: INTEGER);
  67. BEGIN CRS.Error(n, CRS.nextPos)
  68. END Error;
  69. PROCEDURE Get;
  70. BEGIN
  71.     LOOP CRS.Get(sym);
  72.     IF sym > maxT THEN
  73.       IF sym = 39 THEN
  74.          CRS.GetName(CRS.nextPos, CRS.nextLen, str); SetDDT(str) 
  75.       END;
  76.       CRS.nextPos := CRS.pos;
  77.       CRS.nextCol := CRS.col;
  78.       CRS.nextLine := CRS.line;
  79.       CRS.nextLen := CRS.len;
  80.     ELSE EXIT
  81.     END
  82. END Get;
  83. PROCEDURE Expect(n: INTEGER);
  84. BEGIN IF sym = n THEN Get ELSE Error(n) END
  85. END Expect;
  86. PROCEDURE StartOf(s: INTEGER): BOOLEAN;
  87. BEGIN RETURN (sym MOD setSize) IN symSet[s, sym DIV setSize]
  88. END StartOf;
  89. PROCEDURE ExpectWeak(n, follow: INTEGER);
  90. BEGIN
  91.     IF sym = n THEN Get
  92.     ELSE Error(n); WHILE ~ StartOf(follow) DO Get END
  93. END ExpectWeak;
  94. PROCEDURE WeakSeparator(n, syFol, repFol: INTEGER): BOOLEAN;
  95.     VAR s: SymbolSet; i: INTEGER;
  96. BEGIN
  97.     IF sym = n THEN Get; RETURN TRUE
  98.     ELSIF StartOf(repFol) THEN RETURN FALSE
  99.     ELSE
  100.         i := 0; WHILE i < nSets DO s[i] := symSet[syFol, i] + symSet[repFol, i] + symSet[0, i]; INC(i) END;
  101.         Error(n); WHILE ~ ((sym MOD setSize) IN s[sym DIV setSize]) DO Get END;
  102.         RETURN StartOf(syFol)
  103. END WeakSeparator;
  104. PROCEDURE ^TokenFactor(VAR gL, gR: INTEGER);
  105. PROCEDURE ^TokenTerm(VAR gL, gR: INTEGER);
  106. PROCEDURE ^Factor(VAR gL, gR: INTEGER);
  107. PROCEDURE ^Term(VAR gL, gR: INTEGER);
  108. PROCEDURE ^Symbol(VAR name: CRT.Name; VAR kind: INTEGER);
  109. PROCEDURE ^SimSet(VAR set: CRT.Set);
  110. PROCEDURE ^Set(VAR set: CRT.Set);
  111. PROCEDURE ^TokenExpr(VAR gL, gR: INTEGER);
  112. PROCEDURE ^TokenDecl(typ: INTEGER);
  113. PROCEDURE ^SetDecl;
  114. PROCEDURE ^Expression(VAR gL, gR: INTEGER);
  115. PROCEDURE ^SemText(VAR semPos: CRT.Position);
  116. PROCEDURE ^Attribs(VAR attrPos: CRT.Position);
  117. PROCEDURE ^Declaration;
  118. PROCEDURE ^CR;
  119. PROCEDURE TokenFactor(VAR gL, gR: INTEGER);
  120.   VAR kind, c: INTEGER; set: CRT.Set; name: CRT.Name;  
  121. BEGIN
  122.   gL :=0; gR := 0 ;
  123.   IF (sym = 1) OR (sym = 2) THEN
  124.     Symbol(name, kind);
  125.     IF kind = ident THEN
  126.       c := CRT.ClassWithName(name);
  127.       IF c < 0 THEN
  128.         SemErr(15); 
  129.         Sets.Clear(set); c := CRT.NewClass(name, set)
  130.       END;
  131.       gL := CRT.NewNode(CRT.class, c, 0); gR := gL
  132.     ELSE (*string*)
  133.       CRT.StrToGraph(name, gL, gR)
  134.     END ;
  135.   ELSIF (sym = 23) THEN
  136.     Get;
  137.     TokenExpr(gL, gR);
  138.     Expect(24);
  139.   ELSIF (sym = 28) THEN
  140.     Get;
  141.     TokenExpr(gL, gR);
  142.     Expect(29);
  143.     CRT.MakeOption(gL, gR) ;
  144.   ELSIF (sym = 30) THEN
  145.     Get;
  146.     TokenExpr(gL, gR);
  147.     Expect(31);
  148.     CRT.MakeIteration(gL, gR) ;
  149.   ELSE Error(39)
  150.   END;
  151. END TokenFactor;
  152. PROCEDURE TokenTerm(VAR gL, gR: INTEGER);
  153.   VAR gL2, gR2: INTEGER;  
  154. BEGIN
  155.   TokenFactor(gL, gR);
  156.   WHILE StartOf(1)  DO
  157.     TokenFactor(gL2, gR2);
  158.     CRT.ConcatSeq(gL, gR, gL2, gR2) ;
  159.   END;
  160.   IF (sym = 33) THEN
  161.     Get;
  162.     Expect(23);
  163.     TokenExpr(gL2, gR2);
  164.     SetCtx(gL2); CRT.ConcatSeq(gL, gR, gL2, gR2) ;
  165.     Expect(24);
  166.   END;
  167. END TokenTerm;
  168. PROCEDURE Factor(VAR gL, gR: INTEGER);
  169.   VAR sp, kind, c: INTEGER; name: CRT.Name;
  170.       gn: CRT.GraphNode; sn: CRT.SymbolNode;
  171.       set: CRT.Set;
  172.       undef, weak: BOOLEAN;
  173.       pos: CRT.Position;  
  174. BEGIN
  175.   gL :=0; gR := 0; weak := FALSE ;
  176.   CASE sym OF
  177.   | 1,2,27:     IF (sym = 27) THEN
  178.       Get;
  179.       weak := TRUE ;
  180.     END;
  181.     Symbol(name, kind);
  182.     sp := CRT.FindSym(name); undef := sp = CRT.noSym;
  183.     IF undef THEN
  184.       IF kind = ident THEN  (*forward nt*)
  185.         sp := CRT.NewSym(CRT.nt, name, 0)
  186.       ELSE  (*undefined string in production*)
  187.         sp := CRT.NewSym(CRT.t, name, CRS.line);
  188.         MatchLiteral(sp)
  189.       END
  190.     END;
  191.     CRT.GetSym(sp, sn);
  192.     IF ~(sn.typ IN {CRT.t,CRT.nt}) THEN SemErr(4) END;
  193.     IF weak THEN 
  194.       IF sn.typ = CRT.t THEN sn.typ := CRT.wt ELSE SemErr(23) END
  195.     END;
  196.     gL := CRT.NewNode(sn.typ, sp, CRS.line); gR := gL ;
  197.     IF (sym = 34) THEN
  198.       Attribs(pos);
  199.       CRT.GetNode(gL, gn); gn.pos := pos; CRT.PutNode(gL, gn);
  200.       CRT.GetSym(sp, sn);
  201.       IF undef THEN 
  202.         sn.attrPos := pos; CRT.PutSym(sp, sn)
  203.       ELSIF sn.attrPos.beg < 0 THEN SemErr(5)
  204.       END;
  205.       IF kind # ident THEN SemErr(3) END ;
  206.     ELSIF StartOf(2)  THEN
  207.       CRT.GetSym(sp, sn);
  208.       IF sn.attrPos.beg >= 0 THEN SemErr(6) END ;
  209.     ELSE Error(40)
  210.     END;
  211.   | 23:     Get;
  212.     Expression(gL, gR);
  213.     Expect(24);
  214.   | 28:     Get;
  215.     Expression(gL, gR);
  216.     Expect(29);
  217.     CRT.MakeOption(gL, gR) ;
  218.   | 30:     Get;
  219.     Expression(gL, gR);
  220.     Expect(31);
  221.     CRT.MakeIteration(gL, gR) ;
  222.   | 36:     SemText(pos);
  223.     gL := CRT.NewNode(CRT.sem, 0, 0); 
  224.     gR := gL;
  225.     CRT.GetNode(gL, gn); gn.pos := pos; CRT.PutNode(gL, gn) ;
  226.   | 25:     Get;
  227.     Sets.Fill(set); Sets.Excl(set, CRT.eofSy);
  228.     gL := CRT.NewNode(CRT.any, CRT.NewSet(set), 0); gR := gL ;
  229.   | 32:     Get;
  230.     gL := CRT.NewNode(CRT.sync, 0, 0); gR := gL ;
  231.   ELSE Error(41)
  232.   END;
  233. END Factor;
  234. PROCEDURE Term(VAR gL, gR: INTEGER);
  235.   VAR gL2, gR2: INTEGER;  
  236. BEGIN
  237.   gL := 0; gR := 0 ;
  238.   IF StartOf(3)  THEN
  239.     Factor(gL, gR);
  240.     WHILE StartOf(3)  DO
  241.       Factor(gL2, gR2);
  242.       CRT.ConcatSeq(gL, gR, gL2, gR2) ;
  243.     END;
  244.   ELSIF StartOf(4)  THEN
  245.     gL := CRT.NewNode(CRT.eps, 0, 0); gR := gL ;
  246.   ELSE Error(42)
  247.   END;
  248. END Term;
  249. PROCEDURE Symbol(VAR name: CRT.Name; VAR kind: INTEGER);
  250. BEGIN
  251.   IF (sym = 1) THEN
  252.     Get;
  253.     kind := ident ;
  254.   ELSIF (sym = 2) THEN
  255.     Get;
  256.     kind := string ;
  257.   ELSE Error(43)
  258.   END;
  259.   CRS.GetName(CRS.pos, CRS.len, name);
  260.   IF kind = string THEN FixString(name, CRS.len) END ;
  261. END Symbol;
  262. PROCEDURE SimSet(VAR set: CRT.Set);
  263.   VAR c, n, i: INTEGER; name: CRT.Name; s: ARRAY 128 OF CHAR;  
  264. BEGIN
  265.   IF (sym = 1) THEN
  266.     Get;
  267.     CRS.GetName(CRS.pos, CRS.len, name);
  268.     c := CRT.ClassWithName(name);
  269.     IF c < 0 THEN SemErr(15); Sets.Clear(set)
  270.     ELSE CRT.GetClass(c, set)
  271.     END ;
  272.   ELSIF (sym = 2) THEN
  273.     Get;
  274.     CRS.GetName(CRS.pos, CRS.len, s);
  275.     Sets.Clear(set); i := 1; 
  276.     WHILE s[i] # s[0] DO
  277.       Sets.Incl(set, ORD(s[i])); INC(i)
  278.     END ;
  279.   ELSIF (sym = 22) THEN
  280.     Get;
  281.     Expect(23);
  282.     Expect(3);
  283.     CRS.GetName(CRS.pos, CRS.len, name);
  284.     n := 0; i := 0;
  285.     WHILE name[i] # 0X DO
  286.       n := 10 * n + (ORD(name[i]) - ORD("0"));
  287.       INC(i)
  288.     END;
  289.     Sets.Clear(set); Sets.Incl(set, n) ;
  290.     Expect(24);
  291.   ELSIF (sym = 25) THEN
  292.     Get;
  293.     Sets.Fill(set) ;
  294.   ELSE Error(44)
  295.   END;
  296. END SimSet;
  297. PROCEDURE Set(VAR set: CRT.Set);
  298.   VAR set2: CRT.Set;  
  299. BEGIN
  300.   SimSet(set);
  301.   WHILE (sym = 20) OR (sym = 21) DO
  302.     IF (sym = 20) THEN
  303.       Get;
  304.       SimSet(set2);
  305.       Sets.Unite(set, set2) ;
  306.     ELSE
  307.       Get;
  308.       SimSet(set2);
  309.       Sets.Differ(set, set2) ;
  310.     END;
  311.   END;
  312. END Set;
  313. PROCEDURE TokenExpr(VAR gL, gR: INTEGER);
  314.   VAR gL2, gR2: INTEGER; first: BOOLEAN;  
  315. BEGIN
  316.   TokenTerm(gL, gR);
  317.   first := TRUE ;
  318.   WHILE WeakSeparator(26, 1, 5)  DO
  319.     TokenTerm(gL2, gR2);
  320.     IF first THEN 
  321.       CRT.MakeFirstAlt(gL, gR); first := FALSE
  322.     END;
  323.     CRT.ConcatAlt(gL, gR, gL2, gR2) ;
  324.   END;
  325. END TokenExpr;
  326. PROCEDURE TokenDecl(typ: INTEGER);
  327.   VAR sp, kind, gL, gR: INTEGER; sn: CRT.SymbolNode;
  328.       pos: CRT.Position; name: CRT.Name;  
  329. BEGIN
  330.   Symbol(name, kind);
  331.   IF CRT.FindSym(name) # CRT.noSym THEN SemErr(7)
  332.   ELSE 
  333.     sp := CRT.NewSym(typ, name, CRS.line);
  334.     CRT.GetSym(sp, sn); sn.struct := CRT.classToken;
  335.     CRT.PutSym(sp, sn)
  336.   END ;
  337.   WHILE ~( StartOf(6) ) DO Error(45); Get END;
  338.   IF (sym = 8) THEN
  339.     Get;
  340.     TokenExpr(gL, gR);
  341.     Expect(9);
  342.     IF kind # ident THEN SemErr(13) END;
  343.     CRT.CompleteGraph(gR);
  344.     CRA.ConvertToStates(gL, sp) ;
  345.   ELSIF StartOf(7)  THEN
  346.     IF kind = ident THEN genScanner := FALSE
  347.     ELSE MatchLiteral(sp)
  348.     END ;
  349.   ELSE Error(46)
  350.   END;
  351.   IF (sym = 36) THEN
  352.     SemText(pos);
  353.     IF typ = CRT.t THEN SemErr(14) END;
  354.     CRT.GetSym(sp, sn); sn.semPos := pos; CRT.PutSym(sp, sn) ;
  355.   END;
  356. END TokenDecl;
  357. PROCEDURE SetDecl;
  358.   VAR c: INTEGER; set: CRT.Set; name: CRT.Name;  
  359. BEGIN
  360.   Expect(1);
  361.   CRS.GetName(CRS.pos, CRS.len, name);
  362.   c := CRT.ClassWithName(name); IF c >= 0 THEN SemErr(7) END ;
  363.   Expect(8);
  364.   Set(set);
  365.   c := CRT.NewClass(name, set) ;
  366.   Expect(9);
  367. END SetDecl;
  368. PROCEDURE Expression(VAR gL, gR: INTEGER);
  369.   VAR gL2, gR2: INTEGER; first: BOOLEAN;  
  370. BEGIN
  371.   Term(gL, gR);
  372.   first := TRUE ;
  373.   WHILE WeakSeparator(26, 2, 8)  DO
  374.     Term(gL2, gR2);
  375.     IF first THEN 
  376.       CRT.MakeFirstAlt(gL, gR); first := FALSE
  377.     END;
  378.     CRT.ConcatAlt(gL, gR, gL2, gR2) ;
  379.   END;
  380. END Expression;
  381. PROCEDURE SemText(VAR semPos: CRT.Position);
  382. BEGIN
  383.   Expect(36);
  384.   semPos.beg := CRS.nextPos; semPos.col := CRS.nextCol ;
  385.   WHILE StartOf(9)  DO
  386.     Get;
  387.   END;
  388.   Expect(37);
  389.   semPos.len := SHORT(CRS.pos - semPos.beg) ;
  390. END SemText;
  391. PROCEDURE Attribs(VAR attrPos: CRT.Position);
  392. BEGIN
  393.   Expect(34);
  394.   attrPos.beg := CRS.nextPos; attrPos.col := CRS.nextCol ;
  395.   WHILE StartOf(10)  DO
  396.     Get;
  397.   END;
  398.   Expect(35);
  399.   attrPos.len := SHORT(CRS.pos - attrPos.beg) ;
  400. END Attribs;
  401. PROCEDURE Declaration;
  402.   VAR gL1, gR1, gL2, gR2: INTEGER; nested: BOOLEAN;  
  403. BEGIN
  404.   IF (sym = 11) THEN
  405.     Get;
  406.     WHILE (sym = 1) DO
  407.       SetDecl;
  408.     END;
  409.   ELSIF (sym = 12) THEN
  410.     Get;
  411.     WHILE (sym = 1) OR (sym = 2) DO
  412.       TokenDecl(CRT.t);
  413.     END;
  414.   ELSIF (sym = 13) THEN
  415.     Get;
  416.     WHILE (sym = 1) OR (sym = 2) DO
  417.       TokenDecl(CRT.pr);
  418.     END;
  419.   ELSIF (sym = 14) THEN
  420.     Get;
  421.     Expect(15);
  422.     TokenExpr(gL1, gR1);
  423.     Expect(16);
  424.     TokenExpr(gL2, gR2);
  425.     IF (sym = 17) THEN
  426.       Get;
  427.       nested := TRUE ;
  428.     ELSIF StartOf(11)  THEN
  429.       nested := FALSE ;
  430.     ELSE Error(47)
  431.     END;
  432.     CRA.NewComment(gL1, gL2, nested) ;
  433.   ELSIF (sym = 18) THEN
  434.     Get;
  435.     IF (sym = 19) THEN
  436.       Get;
  437.       CRT.ignoreCase := TRUE ;
  438.     ELSIF StartOf(12)  THEN
  439.       Set(CRT.ignored);
  440.     ELSE Error(48)
  441.     END;
  442.   ELSE Error(49)
  443.   END;
  444. END Declaration;
  445. PROCEDURE CR;
  446.   VAR undef, hasAttrs, ok, ok1: BOOLEAN; eofSy, gR: INTEGER; 
  447.       gramLine, sp: INTEGER;
  448.       gn: CRT.GraphNode; sn: CRT.SymbolNode; 
  449.       name, gramName: CRT.Name;  
  450. BEGIN
  451.   Expect(4);
  452.   Texts.OpenWriter(w);
  453.   CRT.Init; CRX.Init; CRA.Init;
  454.   gramLine := CRS.line;
  455.   eofSy := CRT.NewSym(CRT.t, "EOF", 0);
  456.   genScanner := TRUE;
  457.   CRT.ignoreCase := FALSE;
  458.   ok := TRUE;
  459.   Sets.Clear(CRT.ignored) ;
  460.   Expect(1);
  461.   CRS.GetName(CRS.pos, CRS.len, gramName);
  462.   CRT.semDeclPos.beg := CRS.nextPos; CRT.importPos.beg := -1; ;
  463.   WHILE StartOf(13)  DO
  464.     IF (sym = 5) THEN
  465.       Get;
  466.       CRT.importPos.beg := CRS.nextPos ;
  467.       WHILE StartOf(14)  DO
  468.         Get;
  469.       END;
  470.       Expect(6);
  471.       CRT.importPos.len := SHORT(CRS.pos - CRT.importPos.beg);
  472.       CRT.importPos.col := 0;
  473.       CRT.semDeclPos.beg := CRS.nextPos ;
  474.     ELSE
  475.       Get;
  476.     END;
  477.   END;
  478.   CRT.semDeclPos.len := SHORT(CRS.nextPos - CRT.semDeclPos.beg);
  479.   CRT.semDeclPos.col := 0 ;
  480.   WHILE StartOf(15)  DO
  481.     Declaration;
  482.   END;
  483.   WHILE ~( (sym = 0) OR (sym = 7)) DO Error(50); Get END;
  484.   Expect(7);
  485.   IF genScanner THEN CRA.MakeDeterministic(ok) END;
  486.   CRT.nNodes := 0 ;
  487.   WHILE (sym = 1) DO
  488.     Get;
  489.     CRS.GetName(CRS.pos, CRS.len, name); 
  490.     sp := CRT.FindSym(name); undef := sp = CRT.noSym;
  491.     IF undef THEN
  492.       sp := CRT.NewSym(CRT.nt, name, CRS.line);
  493.       CRT.GetSym(sp, sn);
  494.     ELSE
  495.       CRT.GetSym(sp, sn);
  496.       IF sn.typ = CRT.nt THEN
  497.         IF sn.struct > 0 THEN SemErr(7) END
  498.       ELSE SemErr(8)
  499.       END;
  500.       sn.line := CRS.line
  501.     END;
  502.     hasAttrs := sn.attrPos.beg >= 0 ;
  503.     IF (sym = 34) THEN
  504.       Attribs(sn.attrPos);
  505.       IF ~undef & ~hasAttrs THEN SemErr(9) END;
  506.       CRT.PutSym(sp, sn) ;
  507.     ELSIF (sym = 8) OR (sym = 36) THEN
  508.       IF ~undef & hasAttrs THEN SemErr(10) END ;
  509.     ELSE Error(51)
  510.     END;
  511.     IF (sym = 36) THEN
  512.       SemText(sn.semPos);
  513.     END;
  514.     ExpectWeak(8, 16);
  515.     Expression(sn.struct, gR);
  516.     CRT.CompleteGraph(gR); CRT.PutSym(sp, sn);
  517.     IF CRT.ddt[2] THEN CRT.PrintGraph END ;
  518.     ExpectWeak(9, 17);
  519.   END;
  520.   sp := CRT.FindSym(gramName);
  521.   IF sp = CRT.noSym THEN SemErr(11);
  522.   ELSE
  523.     CRT.GetSym(sp, sn); 
  524.     IF sn.attrPos.beg >= 0 THEN SemErr(12) END;
  525.     CRT.root := CRT.NewNode(CRT.nt, sp, gramLine);
  526.   END ;
  527.   Expect(10);
  528.   Expect(1);
  529.   CRS.GetName(CRS.pos, CRS.len, name); 
  530.   IF name # gramName THEN SemErr(17) END;
  531.   IF CRS.errors = 0 THEN
  532.     Texts.WriteString(w, " checking"); Texts.Append(Oberon.Log, w.buf);
  533.     CRT.CompSymbolSets;
  534.     IF ok THEN CRT.TestCompleteness(ok) END;
  535.     IF ok THEN
  536.       CRT.TestIfAllNtReached(ok1); CRT.FindCircularProductions(ok)
  537.     END;
  538.     IF ok THEN CRT.TestIfNtToTerm(ok) END;
  539.     IF ok THEN CRT.LL1Test(ok1) END;
  540.     IF CRT.ddt[0] THEN CRA.PrintStates END;
  541.     IF CRT.ddt[7] THEN CRT.XRef END;
  542.     IF ok THEN
  543.       Texts.WriteString(w, " +parser");
  544.       Texts.Append(Oberon.Log, w.buf);
  545.       CRX.GenCompiler;
  546.       IF genScanner THEN
  547.         Texts.WriteString(w, " +scanner");
  548.         Texts.Append(Oberon.Log, w.buf);
  549.         CRA.WriteScanner
  550.       END;
  551.       IF CRT.ddt[8] THEN CRX.WriteStatistics END
  552.     END
  553.   ELSE ok := FALSE
  554.   END;
  555.   IF CRT.ddt[6] THEN CRT.PrintSymbolTable END;
  556.   IF ok THEN Texts.WriteString(w, " done") END;
  557.   Texts.WriteLn(w); Texts.Append(Oberon.Log, w.buf) ;
  558.   Expect(9);
  559. END CR;
  560. PROCEDURE Parse*;
  561. BEGIN
  562.     Get;
  563.   CR;
  564. END Parse;
  565. BEGIN
  566.   symSet[0, 0] := {0,1,2,7,8,11,12,13,14,18};
  567.   symSet[0, 1] := {4};
  568.   symSet[1, 0] := {1,2,23,28,30};
  569.   symSet[1, 1] := {};
  570.   symSet[2, 0] := {1,2,9,23,24,25,26,27,28,29,30,31};
  571.   symSet[2, 1] := {0,4};
  572.   symSet[3, 0] := {1,2,23,25,27,28,30};
  573.   symSet[3, 1] := {0,4};
  574.   symSet[4, 0] := {9,24,26,29,31};
  575.   symSet[4, 1] := {};
  576.   symSet[5, 0] := {7,9,11,12,13,14,16,17,18,24,29,31};
  577.   symSet[5, 1] := {};
  578.   symSet[6, 0] := {0,1,2,7,8,11,12,13,14,18};
  579.   symSet[6, 1] := {4};
  580.   symSet[7, 0] := {1,2,7,11,12,13,14,18};
  581.   symSet[7, 1] := {4};
  582.   symSet[8, 0] := {9,24,29,31};
  583.   symSet[8, 1] := {};
  584.   symSet[9, 0] := {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
  585.   symSet[9, 1] := {0,1,2,3,4,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
  586.   symSet[10, 0] := {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
  587.   symSet[10, 1] := {0,1,2,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
  588.   symSet[11, 0] := {7,11,12,13,14,18};
  589.   symSet[11, 1] := {};
  590.   symSet[12, 0] := {1,2,22,25};
  591.   symSet[12, 1] := {};
  592.   symSet[13, 0] := {1,2,3,4,5,6,8,9,10,15,16,17,19,20,21,22,23,24,25,26,27,28,29,30,31};
  593.   symSet[13, 1] := {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
  594.   symSet[14, 0] := {1,2,3,4,5,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
  595.   symSet[14, 1] := {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
  596.   symSet[15, 0] := {11,12,13,14,18};
  597.   symSet[15, 1] := {};
  598.   symSet[16, 0] := {0,1,2,7,8,9,11,12,13,14,18,23,25,26,27,28,30};
  599.   symSet[16, 1] := {0,4};
  600.   symSet[17, 0] := {0,1,2,7,8,10,11,12,13,14,18};
  601.   symSet[17, 1] := {4};
  602. END CRP.
  603.   |  0: Msg("EOF expected")
  604.   |  1: Msg("ident expected")
  605.   |  2: Msg("string expected")
  606.   |  3: Msg("number expected")
  607.   |  4: Msg("'COMPILER' expected")
  608.   |  5: Msg("'IMPORT' expected")
  609.   |  6: Msg("';' expected")
  610.   |  7: Msg("'PRODUCTIONS' expected")
  611.   |  8: Msg("'=' expected")
  612.   |  9: Msg("'.' expected")
  613.   | 10: Msg("'END' expected")
  614.   | 11: Msg("'CHARACTERS' expected")
  615.   | 12: Msg("'TOKENS' expected")
  616.   | 13: Msg("'PRAGMAS' expected")
  617.   | 14: Msg("'COMMENTS' expected")
  618.   | 15: Msg("'FROM' expected")
  619.   | 16: Msg("'TO' expected")
  620.   | 17: Msg("'NESTED' expected")
  621.   | 18: Msg("'IGNORE' expected")
  622.   | 19: Msg("'CASE' expected")
  623.   | 20: Msg("'+' expected")
  624.   | 21: Msg("'-' expected")
  625.   | 22: Msg("'CHR' expected")
  626.   | 23: Msg("'(' expected")
  627.   | 24: Msg("')' expected")
  628.   | 25: Msg("'ANY' expected")
  629.   | 26: Msg("'|' expected")
  630.   | 27: Msg("'WEAK' expected")
  631.   | 28: Msg("'[' expected")
  632.   | 29: Msg("']' expected")
  633.   | 30: Msg("'{' expected")
  634.   | 31: Msg("'}' expected")
  635.   | 32: Msg("'SYNC' expected")
  636.   | 33: Msg("'CONTEXT' expected")
  637.   | 34: Msg("'<' expected")
  638.   | 35: Msg("'>' expected")
  639.   | 36: Msg("'(.' expected")
  640.   | 37: Msg("'.)' expected")
  641.   | 38: Msg("??? expected")
  642.   | 39: Msg("invalid TokenFactor")
  643.   | 40: Msg("invalid Factor")
  644.   | 41: Msg("invalid Factor")
  645.   | 42: Msg("invalid Term")
  646.   | 43: Msg("invalid Symbol")
  647.   | 44: Msg("invalid SimSet")
  648.   | 45: Msg("this symbol not expected in TokenDecl")
  649.   | 46: Msg("invalid TokenDecl")
  650.   | 47: Msg("invalid Declaration")
  651.   | 48: Msg("invalid Declaration")
  652.   | 49: Msg("invalid Declaration")
  653.   | 50: Msg("this symbol not expected in CR")
  654.   | 51: Msg("invalid CR")
  655.